常用排序和查找算法的原理及python实现

常用的排序算法：冒泡排序，插入排序，归并排序,　快速排序、基数排序、堆排序，直接选择排序。
常用的查找算法：顺序查找，二分查找，哈希表查找和二叉树查找

其中我们应该重点掌握二分查找、归并排序和快速排序，保证能随时正确、完整地写出它们的代码。同时对其他的查找和排序必须能准确说出它们的特点、对其平均时间复杂度、最差时间复杂度、额外空间消耗和稳定性烂熟于胸.

排序算法的稳定性：假设在待排序的记录序列中，存在多个具有相同关键字的记录，若经过排序，这些记录的相对次序保持不变。即在原序列中$r[i]=r[j]$， 且$r[i]$在$r[j]$之前，而在排序后的序列中，$r[i]$仍在$r[j]$之前,则称这种排序算法是稳定的；否则是不稳定的

算法性能总览

排序方法	最坏时间复杂度	最优时间复杂度	平均时间复杂度	空间复杂度	稳定性
冒泡排序	$O( {\displaystyle n^{2}})$	$O( {\displaystyle n})$	$O( {\displaystyle n^{2}})$	$O( {\displaystyle n})$,　辅助空间$O( {\displaystyle {１}})$	稳定
插入排序	$O( {\displaystyle n^{2}})$	$O( {\displaystyle n})$	$O( {\displaystyle n^{2}})$	$O( {\displaystyle n})$,　辅助空间$O( {\displaystyle {１}})$	稳定
归并排序	$O( {\displaystyle n{logn}})$	$O( {\displaystyle n})$	$O( {\displaystyle n{logn}})$	$O( {\displaystyle n})$	稳定
快速排序	$O( {\displaystyle n^{2}})$	$O( {\displaystyle n{logn}})$	$O( {\displaystyle n{logn}})$	根据实现的方式不同而不同	不稳定

1. 冒泡排序

冒泡排序(Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元${\displaystyle n}$个项目需要$O( {\displaystyle n^{2}})$ 的比较次数，且可以原地排序。尽管这个算法是最简单了解和实现的排序算法之一，但它对于包含大量的元素的数列排序是很没有效率的

算法描述：
1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

def bubble_sort(lst):
    if len(lst) <= 1:
        return lst
    for ind in range(len(lst)-1,0,-1):
        flag = False
        for sub_ind in range(ind):
            if lst[sub_ind] > lst[sub_ind + 1]:
                lst[sub_ind], lst[sub_ind+1] = lst[sub_ind+1], lst[sub_ind]
                flag = True
        if flag == False:
            break
    return lst

2. 插入排序

插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到 ${\displaystyle O(1)}$ 的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间

算法描述

1. 从第一个元素开始，该元素可以认为已经被排序
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5. 将新元素插入到该位置后
6. 重复步骤2~5

def insertion_sort(lst):
    if len(lst) == 1:
        return lst

    for i in range(1, len(lst)):
        temp = lst[i]
        j = i - 1
        while j >= 0 and temp < lst[j]:
            lst[j + 1] = lst[j]
            j -= 1
        lst[j + 1] = temp
    return lst

3. 归并排序

归并排序（mergesort），是创建在归并操作上的一种有效的排序算法，效率为 ${\displaystyle O(n\log n)}$。1945年由约翰·冯·诺伊曼首次提出。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行

算法描述
迭代法
1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4. 重复步骤3直到某一指针到达序列尾
5. 将另一序列剩下的所有元素直接复制到合并序列尾

递归法
1. 将序列每相邻两个数字进行归并操作，形成 ${\displaystyle ceil(n/2)}$ 个序列，排序后每个序列包含两/一个元素
2. 若此时序列数不是1个则将上述序列再次归并，形成 ${\displaystyle ceil(n/4)}$ 个序列，每个序列包含四/三个元素
3. 重复步骤2，直到所有元素排序完毕，即序列数为1

def merge_sort(lst):
    if len(lst) <= 1:
        return lst

    def merge(left, right):
        merged,left,right = deque(),deque(left),deque(right)
        while left and right:
            merged.append(left.popleft() if left[0] <= right[0] else right.popleft())  # deque popleft is also O(1)
        merged.extend(right if right else left)
        return list(merged)

    middle = int(len(lst) // 2)
    left = merge_sort(lst[:middle])
    right = merge_sort(lst[middle:])
    return merge(left, right)

4. 快速排序

快速排序（Quicksort），在平均状况下，排序 ${\displaystyle n}$ 个项目要 ${\displaystyle O(n\log n)}$）次比较。在最坏状况下则需要 ${\displaystyle O(n^{2})}$次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 ${\displaystyle O(n\log n)}$ 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出

算法描述：
快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）
1. 从数列中挑出一个元素，称为”基准”（pivot）
2. 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任何一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作
3. 递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序

def quicksort(lst):
    less = []
    greater = []
    if len(lst) <= 1:
        return lst
    else:
        pivot = lst[-1]
        for num in lst[:-1]:
            if num < pivot:
                less.append(num)
            if num >= pivot:
                greater.append(num)
        return quicksort(less) + [pivot] + quicksort(greater)

in-place版本

 def quicksort(lst, lo, hi):
      if lo < hi:
         p = partition(lst, lo, hi)
         quicksort(lst, lo, p)
         quicksort(lst, p+1, hi)
     return

 def partition(lst, lo, hi):
     pivot = lst[hi-1]
     i = lo - 1
     for j in range(lo, hi):
         if lst[j] < pivot:
             i += 1
             lst[i], lst[j] = lst[j], lst[i]
     if lst[hi-1] < lst[i+1]:
         lst[i+1], lst[hi-1] = lst[hi-1], lst[i+1]
     return i+1

5. 基数排序

6. 堆排序

7. 直接选择排序

1 .顺序查找

2. 二分查找

在计算机科学中，二分搜索（binary search），是一种在有序数组中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半

算法描述
给予一个包含 ${\displaystyle n}$个带值元素的数组A
1. 令 L为0 ， R为 n-1
2. 如果L>R，则搜索以失败告终
3. 令m(中间值元素)为${\displaystyle \lfloor (L+R)/2\rfloor }$
4. 如果 ${\displaystyle A_{m}<T}$，令 ${\displaystyle L}$为 ${\displaystyle m+1}$ 并回到步骤二
5. 如果 ${\displaystyle A_{m}>T}$ ，令 ${\displaystyle R}$ 为 ${\displaystyle m-1}$并回到步骤二

def binary_search(arr,start,end,hkey):
    if start > end:
        return -1
    mid = start + (end - start) / 2
    if arr[mid] > hkey:
        return binary_search(arr, start, mid - 1, hkey)
    if arr[mid] < hkey:
        return binary_search(arr, mid + 1, end, hkey)
    return mid

复杂度分析
时间复杂度: 折半搜索每次把搜索区域减少一半，时间复杂度为 ${\displaystyle O\left(\log n\right)}$
空间复杂度${\displaystyle O\left(1\right)}$。虽以递归形式定义，但是尾递归，可改写为循环。

3. 哈希表查找

4. 二叉树查找